package com.example.demo.ai.impl;

import com.example.demo.ai.NewInterviewService;
import com.example.demo.ai.config.DeepSeekConfig;
import com.example.demo.ai.model.*;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * 新的AI面试服务实现类
 * 提供高效的面试问题生成和答案分析功能
 */
@Service
public class NewInterviewServiceImpl implements NewInterviewService {

    private static final Logger logger = LoggerFactory.getLogger(NewInterviewServiceImpl.class);

    @Autowired
    private DeepSeekConfig config;

    private final RestTemplate restTemplate = new RestTemplate();
    private final ObjectMapper objectMapper = new ObjectMapper();
    private static final int MAX_RETRY_COUNT = 3; // 最大重试次数
    private static final long RETRY_INTERVAL_MS = 1000; // 重试间隔

    @Override
    public List<String> generateInterviewQuestions(String resumeText, String jobTitle, String jobDescription,
            String industry, Integer difficulty, Integer questionCount) {
        logger.info("生成面试问题，职位: {}, 数量: {}, 难度: {}", jobTitle, questionCount, difficulty);
        try {
            String prompt = buildQuestionsPrompt(resumeText, jobTitle, jobDescription, industry, difficulty,
                    questionCount);
            String response = callDeepSeekApiWithRetry(prompt);
            List<String> questions = parseGeneratedQuestions(response);

            // 如果生成的问题数量不足，补充默认问题
            if (questions.size() < questionCount) {
                questions = addDefaultQuestionsIfNeeded(questions, jobTitle, questionCount);
            }

            return questions;
        } catch (Exception e) {
            logger.error("生成面试问题失败: {}", e.getMessage(), e);
            return generateDefaultQuestions(jobTitle, questionCount);
        }
    }

    @Override
    public String generateSingleQuestion(String resumeText, String jobTitle, String jobDescription,
            String industry, Integer difficulty, List<String> previousQuestions) {
        logger.info("生成单个面试问题，职位: {}", jobTitle);
        try {
            String prompt = buildSingleQuestionPrompt(resumeText, jobTitle, jobDescription, industry, difficulty,
                    previousQuestions);
            String response = callDeepSeekApiWithRetry(prompt);
            return extractSingleQuestion(response);
        } catch (Exception e) {
            logger.error("生成单个面试问题失败: {}", e.getMessage(), e);
            return generateDefaultSingleQuestion(jobTitle);
        }
    }

    @Override
    public String generateSingleQuestionWithContext(String resumeText, String jobTitle, String jobDescription,
            String industry, Integer difficulty, List<InterviewQA> qaList) {
        logger.info("生成带上下文的单个面试问题，职位: {}", jobTitle);
        try {
            String prompt = buildSingleQuestionWithContextPrompt(resumeText, jobTitle, jobDescription, industry,
                    difficulty, qaList);
            String response = callDeepSeekApiWithRetry(prompt);
            return extractSingleQuestion(response);
        } catch (Exception e) {
            logger.error("生成带上下文的单个面试问题失败: {}", e.getMessage(), e);
            // 如果失败，回退到不使用上下文的方式
            List<String> previousQuestions = new ArrayList<>();
            if (qaList != null) {
                for (InterviewQA qa : qaList) {
                    previousQuestions.add(qa.getQuestion());
                }
            }
            return generateSingleQuestion(resumeText, jobTitle, jobDescription, industry, difficulty,
                    previousQuestions);
        }
    }

    @Override
    public InterviewAnalysis analyzeInterviewAnswers(String resumeText, List<InterviewQA> qaList, String jobTitle) {
        logger.info("分析面试答案，职位: {}", jobTitle);
        try {
            if (qaList == null || qaList.isEmpty()) {
                logger.warn("没有可用的问答记录进行分析");
                return getDefaultInterviewAnalysis();
            }

            String prompt = buildAnswerAnalysisPrompt(resumeText, qaList, jobTitle);
            String response = callDeepSeekApiWithRetry(prompt);
            return parseInterviewAnalysis(response);
        } catch (Exception e) {
            logger.error("分析面试答案失败: {}", e.getMessage(), e);
            return getDefaultInterviewAnalysis();
        }
    }

    // 为了避免编译错误，这里暂时移除旧的单个答案分析实现
    // 新的实现见下面的annotate方法

    // 解析单个答案分析结果
    private InterviewAnalysis parseSingleAnswerAnalysis(String response) {
        InterviewAnalysis analysis = new InterviewAnalysis();
        try {
            Double score = extractValue(response, "面试得分：", Double.class);
            analysis.setScore(score != null ? score : 75.0);

            String suggestion = extractValue(response, "综合评价：", String.class);
            analysis.setSuggestion(suggestion != null ? suggestion : "您的回答基本符合要求，有一定的专业基础。");

            String strengthsStr = extractValue(response, "优势：", String.class);
            if (strengthsStr != null && !strengthsStr.isEmpty()) {
                List<String> strengths = Arrays.asList(strengthsStr.split("，"));
                analysis.setStrengths(new ArrayList<>(strengths));
            } else {
                analysis.setStrengths(Arrays.asList("回答内容充实", "思路清晰", "表达流畅"));
            }

            String improvementsStr = extractValue(response, "改进建议：", String.class);
            if (improvementsStr != null && !improvementsStr.isEmpty()) {
                List<String> improvements = Arrays.asList(improvementsStr.split("，"));
                analysis.setAreasForImprovement(new ArrayList<>(improvements));
            } else {
                analysis.setAreasForImprovement(Arrays.asList("可以更详细地描述项目经验", "加强技术深度", "提高问题分析能力"));
            }

        } catch (Exception e) {
            logger.error("解析面试分析结果失败: {}", e.getMessage());
            return getDefaultInterviewAnalysis();
        }

        return analysis;
    }

    // 生成模拟单个答案分析结果
    private InterviewAnalysis generateMockSingleAnswerAnalysis() {
        InterviewAnalysis analysis = new InterviewAnalysis();
        // 随机生成一些分数，使模拟结果看起来更真实
        analysis.setScore(70 + Math.random() * 15);
        
        analysis.setSuggestion("根据您的回答，您在该方面有一定的了解，但可以进一步深入。回答结构清晰，能够较好地表达自己的观点。建议在回答中结合更多具体案例，展示实际应用能力。");
        
        List<String> strengths = new ArrayList<>();
        strengths.add("回答内容充实，有自己的见解");
        strengths.add("表达逻辑清晰，重点突出");
        strengths.add("能够结合专业知识进行分析");
        analysis.setStrengths(strengths);
        
        List<String> areasForImprovement = new ArrayList<>();
        areasForImprovement.add("可以更深入地探讨技术细节和实现方案");
        areasForImprovement.add("回答问题时可以结合更多具体项目案例");
        areasForImprovement.add("可以增加对行业最新发展趋势的了解");
        analysis.setAreasForImprovement(areasForImprovement);
        
        return analysis;
    }

    @Override
    public ResumeAnalysis analyzeResume(String resumeText, String jobTitle) {
        logger.info("分析简历内容，目标职位: {}", jobTitle);
        try {
            String prompt = buildResumeAnalysisPrompt(resumeText, jobTitle);
            String response = callDeepSeekApiWithRetry(prompt);
            return parseResumeAnalysis(response);
        } catch (Exception e) {
            logger.error("分析简历失败: {}", e.getMessage(), e);
            return getDefaultResumeAnalysis();
        }
    }

    @Override
    public List<InterviewQA> generateExampleAnswers(String resumeText, List<InterviewQA> qaList, String jobTitle) {
        logger.info("生成示例答案，职位: {}", jobTitle);
        try {
            if (qaList == null || qaList.isEmpty()) {
                logger.warn("没有可用的问答记录生成示例答案");
                return generateDefaultExampleAnswers(jobTitle);
            }

            String prompt = buildExampleAnswersPrompt(resumeText, qaList, jobTitle);
            String response = callDeepSeekApiWithRetry(prompt);
            return parseExampleAnswers(response, qaList);
        } catch (Exception e) {
            logger.error("生成示例答案失败: {}", e.getMessage(), e);
            return generateDefaultExampleAnswers(jobTitle);
        }
    }

    // 构建面试问题生成提示词
    private String buildQuestionsPrompt(String resumeText, String jobTitle, String jobDescription,
            String industry, Integer difficulty, Integer questionCount) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("作为一个经验丰富的面试官，根据以下简历和职位信息，为应聘者生成").append(questionCount)
                .append("个专业的面试问题：\n\n");

        prompt.append("### 简历信息：\n")
                .append(resumeText).append("\n\n");

        prompt.append("### 职位信息：\n");
        prompt.append("职位名称：").append(jobTitle).append("\n");

        if (jobDescription != null && !jobDescription.isEmpty()) {
            prompt.append("职位描述：").append(jobDescription).append("\n");
        }

        if (industry != null && !industry.isEmpty()) {
            prompt.append("行业：").append(industry).append("\n");
        }

        prompt.append("难度级别：").append(getDifficultyDescription(difficulty)).append("\n\n");

        prompt.append("请按照以下要求生成问题：\n");
        prompt.append("1. 问题应紧密结合职位需求和应聘者简历，考察其专业技能和经验\n");
        prompt.append("2. 覆盖技术知识、项目经验、问题解决能力和团队协作等多个方面\n");
        prompt.append("3. 问题表述清晰，不要使用过于模糊或歧义的表述\n");
        prompt.append("4. 请按序号列出所有问题，每个问题占一行\n");
        prompt.append("5. 不要添加任何额外的说明文字\n");

        return prompt.toString();
    }

    // 构建单个问题生成提示词
    private String buildSingleQuestionPrompt(String resumeText, String jobTitle, String jobDescription,
            String industry, Integer difficulty, List<String> previousQuestions) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("作为一个经验丰富的面试官，根据以下简历、职位信息和之前的问题，生成一个新的面试问题：\n\n");

        prompt.append("### 简历信息：\n")
                .append(resumeText).append("\n\n");

        prompt.append("### 职位信息：\n");
        prompt.append("职位名称：").append(jobTitle).append("\n");

        if (jobDescription != null && !jobDescription.isEmpty()) {
            prompt.append("职位描述：").append(jobDescription).append("\n");
        }

        if (industry != null && !industry.isEmpty()) {
            prompt.append("行业：").append(industry).append("\n");
        }

        prompt.append("难度级别：").append(getDifficultyDescription(difficulty)).append("\n\n");

        // 添加之前的问题
        if (previousQuestions != null && !previousQuestions.isEmpty()) {
            prompt.append("### 之前的问题：\n");
            for (int i = 0; i < previousQuestions.size(); i++) {
                prompt.append("问题").append(i + 1).append(": ")
                        .append(previousQuestions.get(i)).append("\n");
            }
            prompt.append("\n请生成一个与之前问题不重复，但能够深入考察应聘者相关能力的新问题。\n");
        }

        prompt.append("请仅输出新问题，不要添加序号或其他说明。");

        return prompt.toString();
    }

    // 构建结合用户回答的单个问题生成提示词
    private String buildSingleQuestionWithContextPrompt(String resumeText, String jobTitle, String jobDescription,
            String industry, Integer difficulty, List<InterviewQA> qaList) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("根据以下简历、职位信息和用户之前的问答记录，生成一个新的面试问题：\n\n");

        prompt.append("### 简历信息：\n")
                .append(resumeText).append("\n\n");

        prompt.append("### 职位信息：\n");
        prompt.append("职位名称：").append(jobTitle).append("\n");

        if (jobDescription != null && !jobDescription.isEmpty()) {
            prompt.append("职位描述：").append(jobDescription).append("\n");
        }

        if (industry != null && !industry.isEmpty()) {
            prompt.append("行业：").append(industry).append("\n");
        }

        prompt.append("难度级别：").append(getDifficultyDescription(difficulty)).append("\n\n");

        // 添加之前的问答记录
        if (qaList != null && !qaList.isEmpty()) {
            prompt.append("### 之前的问答记录：\n");
            for (int i = 0; i < qaList.size(); i++) {
                prompt.append("问题").append(i + 1).append(": ")
                        .append(qaList.get(i).getQuestion()).append("\n");
                prompt.append("回答").append(i + 1).append(": ")
                        .append(qaList.get(i).getAnswer()).append("\n\n");
            }
            prompt.append("请基于用户的回答内容，深入挖掘相关的专业知识、经验或能力，生成一个更有针对性的新问题。\n");
            prompt.append("新问题应该与用户的回答内容紧密相关，能够进一步考察用户的专业水平和实际经验。\n");
        }

        prompt.append("请仅输出新问题，不要添加序号或其他说明。");

        return prompt.toString();
    }

    // 构建面试答案分析提示词
    private String buildAnswerAnalysisPrompt(String resumeText, List<InterviewQA> qaList, String jobTitle) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("作为一位资深人力资源专家，根据以下简历、职位信息和面试问答记录，对面试者的表现进行全面分析：\n\n");

        prompt.append("### 简历信息：\n").append(resumeText).append("\n\n");
        prompt.append("### 目标职位：\n").append(jobTitle).append("\n\n");

        prompt.append("### 面试问答记录：\n");
        for (int i = 0; i < qaList.size(); i++) {
            prompt.append("问题").append(i + 1).append(": ").append(qaList.get(i).getQuestion()).append("\n");
            prompt.append("回答").append(i + 1).append(": ").append(qaList.get(i).getAnswer()).append("\n\n");
        }

        prompt.append("请按照以下格式输出分析结果：\n");
        prompt.append("面试得分：[0-100的数字]\n");
        prompt.append("综合评价：[对面试者整体表现的总结]\n");
        prompt.append("优势：[列出面试者的主要优势，用逗号分隔]\n");
        prompt.append("改进建议：[列出面试者需要改进的地方，用逗号分隔]\n");

        prompt.append("请注意：\n");
        prompt.append("1. 分析应客观公正，基于问答内容和职位需求\n");
        prompt.append("2. 优势和改进建议应具体明确，避免泛泛而谈\n");
        prompt.append("3. 请严格按照指定格式输出，不要添加任何额外内容\n");

        return prompt.toString();
    }

    // 构建简历分析提示词
    private String buildResumeAnalysisPrompt(String resumeText, String jobTitle) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("作为一位资深的简历评估专家，根据以下简历内容和目标职位，进行专业的简历分析：\n\n");

        prompt.append("### 简历内容：\n").append(resumeText).append("\n\n");
        prompt.append("### 目标职位：\n").append(jobTitle).append("\n\n");

        prompt.append("请按照以下格式输出分析结果：\n");
        prompt.append("匹配度：[0-100的数字]\n");
        prompt.append("优势：[列出简历中的主要优势，用逗号分隔]\n");
        prompt.append("不足：[列出简历中的主要不足，用逗号分隔]\n");
        prompt.append("建议：[提供改进简历的具体建议]\n");
        prompt.append("格式优化建议：[提供简历格式优化的建议]\n");

        prompt.append("请注意：\n");
        prompt.append("1. 分析应基于简历内容和目标职位的匹配度\n");
        prompt.append("2. 优势和不足应具体明确，避免泛泛而谈\n");
        prompt.append("3. 请严格按照指定格式输出，不要添加任何额外内容\n");

        return prompt.toString();
    }

    // 构建示例答案生成提示词
    private String buildExampleAnswersPrompt(String resumeText, List<InterviewQA> qaList, String jobTitle) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("基于以下简历内容、职位信息和实际问答记录，生成专业的示例答案：\n\n");

        prompt.append("### 简历内容：\n").append(resumeText).append("\n\n");
        prompt.append("### 目标职位：\n").append(jobTitle).append("\n\n");

        prompt.append("### 实际问答记录：\n");
        for (int i = 0; i < qaList.size(); i++) {
            prompt.append("问题").append(i + 1).append(": ").append(qaList.get(i).getQuestion()).append("\n");
            prompt.append("回答").append(i + 1).append(": ").append(qaList.get(i).getAnswer()).append("\n\n");
        }

        prompt.append("请为每个问题生成一个专业的示例答案，要求：\n");
        prompt.append("1. 答案应符合目标职位的要求和简历内容\n");
        prompt.append("2. 答案应详细、具体，体现专业知识和实际工作经验\n");
        prompt.append("3. 答案应结构清晰，逻辑严谨，重点突出\n");
        prompt.append("4. 答案应包含具体的案例、数据或技术细节，展示实际解决问题的能力\n");
        prompt.append("5. 请按照问题序号依次列出每个问题的示例答案\n");
        prompt.append("6. 每个问题的示例答案前请标明\"示例答案X：\"，其中X为问题序号\n");
        prompt.append("7. 不要添加任何额外的说明文字\n");

        return prompt.toString();
    }

    // 构建单例示例答案生成提示词
    private String buildSingleExampleAnswerPrompt(String resumeText, String question, String jobTitle) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("请为以下面试问题生成一个高质量的参考答案：\n\n");
        prompt.append("### 问题：\n").append(question).append("\n\n");
        
        if (jobTitle != null && !jobTitle.isEmpty()) {
            prompt.append("### 目标岗位：\n").append(jobTitle).append("\n\n");
        }
        
        if (resumeText != null && !resumeText.isEmpty()) {
            prompt.append("### 简历概要：\n").append(resumeText.length() > 200 ? resumeText.substring(0, 200) + "..." : resumeText).append("\n\n");
        }
        
        prompt.append("请按照以下要求生成参考答案：\n");
        prompt.append("1. 结构清晰，逻辑严谨，表达流畅\n");
        prompt.append("2. 内容详实，突出重点，体现专业知识\n");
        prompt.append("3. 符合目标岗位的要求和期望\n");
        prompt.append("4. 包含具体的案例、数据或技术细节，展示实际解决问题的能力\n");
        prompt.append("5. 如果提供了简历概要，请尽量与简历内容相匹配\n");
        prompt.append("6. 请仅输出参考答案内容，不要添加其他说明文字\n");

        return prompt.toString();
    }

    // 带重试机制的API调用和模拟数据支持
    private String callDeepSeekApiWithRetry(String prompt) throws Exception {
        int retryCount = 0;
        Exception lastException = null;

        while (retryCount < MAX_RETRY_COUNT) {
            try {
                return callDeepSeekApi(prompt);
            } catch (Exception e) {
                retryCount++;
                lastException = e;
                logger.warn("API调用失败，正在重试 ({}/{}): {}", retryCount, MAX_RETRY_COUNT, e.getMessage());

                if (retryCount < MAX_RETRY_COUNT) {
                    TimeUnit.MILLISECONDS.sleep(RETRY_INTERVAL_MS * retryCount); // 指数退避
                }
            }
        }

        logger.error("API调用失败，已达到最大重试次数，返回模拟数据");
        // 根据提示词类型返回对应的模拟数据
        if (prompt.contains("生成一个新的面试问题")) {
            return generateMockQuestion();
        } else if (prompt.contains("对面试者的表现进行全面分析")) {
            return generateMockAnalysis();
        } else if (prompt.contains("生成专业的示例答案")) {
            return generateMockExampleAnswers();
        } else if (prompt.contains("进行专业的简历分析")) {
            return generateMockResumeAnalysis();
        }
        
        throw new Exception("API调用失败，已达到最大重试次数", lastException);
    }
    
    // 生成模拟面试问题
    private String generateMockQuestion() {
        List<String> mockQuestions = Arrays.asList(
            "请详细描述您在过去项目中使用Java的经验？",
            "您如何理解面向对象编程的核心概念？请举例说明。",
            "您在工作中是如何解决技术难题的？可以分享一个具体案例吗？",
            "请谈谈您对Spring框架的理解和使用经验。",
            "您如何处理团队合作中的冲突？"
        );
        return mockQuestions.get(new Random().nextInt(mockQuestions.size()));
    }
    
    // 生成模拟面试分析
    private String generateMockAnalysis() {
        return "面试得分：82\n" +
               "综合评价：面试者具备扎实的专业基础和良好的沟通能力，对岗位要求有较深理解。\n" +
               "优势：专业知识扎实，沟通表达清晰，有良好的问题解决能力。\n" +
               "改进建议：可以更详细地描述项目经验中的技术细节，加强对新技术的了解。";
    }
    
    @Override
    public String generateSingleExampleAnswer(String resumeText, String question, String jobTitle) {
        logger.info("生成单个示例答案，问题: {}", question);
        try {
            // 构建提示词
            String prompt = buildSingleExampleAnswerPrompt(resumeText, question, jobTitle);
            // 调用AI API获取示例答案
            String response = callDeepSeekApiWithRetry(prompt);
            return response;
        } catch (Exception e) {
            logger.error("生成示例答案失败: {}", e.getMessage(), e);
            // 返回模拟示例答案
            return generateMockSingleExampleAnswer(question);
        }
    }
    
    // 生成模拟示例答案
    private String generateMockExampleAnswers() {
        return "示例答案1：在我之前的项目中，我主要使用Java作为后端开发语言，负责设计和实现RESTful API，处理数据库交互，以及优化系统性能。我熟悉Java 8及以上版本的新特性，如Lambda表达式、Stream API等，并在实际项目中广泛应用。在最近的一个电商平台项目中，我负责重构了订单模块，通过引入缓存机制和优化数据库查询，使系统响应时间降低了40%。\n\n" +
                "示例答案2：面向对象编程的核心概念包括封装、继承和多态。封装是将数据和方法封装在类中，隐藏内部实现细节；继承允许创建新类基于现有类，重用代码；多态允许使用父类引用指向子类对象，实现方法的动态绑定。在实际开发中，我经常使用这些概念来设计可扩展、可维护的系统架构，例如通过接口和抽象类实现组件的解耦。\n\n" +
                "示例答案3：在团队开发中，冲突是难免的，主要源于对技术方案的不同理解或对工作进度的分歧。我的解决方法是：首先保持开放的心态，尊重团队成员的观点；然后通过深入讨论，了解各方的顾虑和出发点；最后基于项目目标和技术可行性，寻求最优解。在这个过程中，我会特别注重数据和事实，避免主观判断。如果确实无法达成一致，我会建议先进行小范围的原型验证，通过实际效果来做最终决定。\n\n" +
                "示例答案4：在之前的项目中，我们遇到了一个性能瓶颈：当用户量激增时，系统响应时间明显增加。我通过分析日志和使用监控工具，发现数据库查询是主要瓶颈。我的解决方案包括：1）优化SQL查询语句，添加合适的索引；2）引入缓存机制，将频繁访问的数据缓存到Redis中；3）对数据库进行读写分离，减轻主库压力。这些优化措施使系统的响应时间降低了60%，能够支持更多的并发用户。";
    }
    
    @Override
    public InterviewAnalysis analyzeInterviewAnswer(String resumeText, String userAnswer, String question, String jobTitle) {
        logger.info("分析面试答案，问题: {}", question);
        try {
            // 构建提示词
            String prompt = buildAnalyzeAnswerPrompt(resumeText, userAnswer, question, jobTitle);
            // 调用AI API获取分析结果
            String response = callDeepSeekApiWithRetry(prompt);
            
            // 解析AI响应，构建InterviewAnalysis对象
            return parseAnalysisResponse(response);
        } catch (Exception e) {
            logger.error("分析面试答案失败: {}", e.getMessage(), e);
            // 返回模拟分析结果
            return generateMockSingleAnswerAnalysis(question, userAnswer);
        }
    }
    
    // 生成单个模拟示例答案
    private String generateMockSingleExampleAnswer(String question) {
        Map<String, String> mockAnswers = new HashMap<>();
        
        mockAnswers.put("请介绍一下你自己。", "您好，我是一名拥有3年Java开发经验的软件工程师。我毕业于XX大学计算机科学专业，目前在XX公司担任后端开发工程师。我熟悉Java、Spring Boot、MySQL等技术，有丰富的Web应用开发经验。在工作中，我参与过多个大型项目的开发，负责后端架构设计和核心功能实现。我善于团队合作，能够快速适应新的技术环境，并且有良好的学习能力。");
        
        mockAnswers.put("请谈谈你对Spring Boot的理解。", "Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。Spring Boot的核心功能包括：自动配置、起步依赖、命令行界面、Actuator监控等。通过使用Spring Boot，我们可以快速创建独立的、产品级别的基于Spring的应用程序。在我之前的项目中，我使用Spring Boot构建了多个微服务，大大提高了开发效率和系统稳定性。");
        
        mockAnswers.put("你是如何解决团队开发中的冲突的？", "在团队开发中，冲突是难免的，主要源于对技术方案的不同理解或对工作进度的分歧。我的解决方法是：首先保持开放的心态，尊重团队成员的观点；然后通过深入讨论，了解各方的顾虑和出发点；最后基于项目目标和技术可行性，寻求最优解。在这个过程中，我会特别注重数据和事实，避免主观判断。如果确实无法达成一致，我会建议先进行小范围的原型验证，通过实际效果来做最终决定。例如，在之前的一个项目中，团队对于是否使用微服务架构存在分歧，我建议先构建一个小型原型，通过对比分析，最终说服了团队采用微服务架构。");
        
        mockAnswers.put("请描述一个你遇到的技术挑战及解决方案。", "在之前的项目中，我们遇到了一个性能瓶颈：当用户量激增时，系统响应时间明显增加。我通过分析日志和使用监控工具，发现数据库查询是主要瓶颈。我的解决方案包括：1）优化SQL查询语句，添加合适的索引；2）引入缓存机制，将频繁访问的数据缓存到Redis中；3）对数据库进行读写分离，减轻主库压力。这些优化措施使系统的响应时间降低了60%，能够支持更多的并发用户。这次经历让我深刻认识到性能优化的重要性，并且掌握了多种优化手段。");
        
        // 如果有匹配的问题，则返回对应的模拟答案
        if (mockAnswers.containsKey(question)) {
            return mockAnswers.get(question);
        }
        
        // 如果没有匹配的问题，则返回一个通用的模拟答案
        return "这是一个很好的问题。在实际工作中，我会从以下几个方面来考虑：首先，我会分析问题的核心需求和目标；然后，我会评估各种可能的解决方案；最后，我会选择最优的方案并实施。在这个过程中，我会注重团队合作，充分听取他人的意见和建议，确保最终的解决方案能够满足项目的需求，并且具有良好的可扩展性和可维护性。";    
    }
    
    // 生成单个答案的模拟分析结果
    private InterviewAnalysis generateMockSingleAnswerAnalysis(String question, String userAnswer) {
        InterviewAnalysis analysis = new InterviewAnalysis();
        analysis.setScore((double) generateRandomScore());
        
        // 优势和改进空间
        List<String> strengths = new ArrayList<>();
        List<String> areasForImprovement = new ArrayList<>();
        
        // 根据问题类型生成相应的优势和改进空间
        if (question.contains("介绍")) {
            strengths.add("回答简洁明了，重点突出，能够清晰地介绍自己的背景和经验。");
            areasForImprovement.add("可以进一步突出自己的核心竞争力和与应聘岗位的匹配度。");
        } else if (question.contains("Spring") || question.contains("技术")) {
            strengths.add("对技术有一定的理解，能够清晰地表达自己的观点。");
            areasForImprovement.add("可以结合具体项目经验，更详细地说明如何应用这些技术解决实际问题。");
        } else if (question.contains("团队")) {
            strengths.add("能够认识到团队合作的重要性，有一定的团队协作经验。");
            areasForImprovement.add("可以提供更具体的团队协作案例，说明自己在团队中的角色和贡献。");
        } else if (question.contains("挑战")) {
            strengths.add("有解决问题的意识和能力，能够积极面对挑战。");
            areasForImprovement.add("可以更详细地说明解决问题的具体步骤和方法，以及从中获得的经验教训。");
        } else {
            strengths.add("回答切题，能够针对问题提供有效信息。");
            areasForImprovement.add("可以结合更多实际案例和具体数据，使回答更有说服力。");
        }
        
        analysis.setStrengths(strengths);
        analysis.setAreasForImprovement(areasForImprovement);
        
        // 总体建议
        analysis.setSuggestion("回答整体良好，但仍有提升空间。建议在后续回答中更加具体、深入，结合实际案例和数据来支持自己的观点，突出自己的核心竞争力和与应聘岗位的匹配度。");
        
        return analysis;
    }
    
    // 生成随机评分（70-85之间）
    private int generateRandomScore() {
        Random random = new Random();
        return 70 + random.nextInt(16); // 生成70到85之间的随机数
    }
    
    // 构建单个答案分析的提示词
    private String buildAnalyzeAnswerPrompt(String resumeText, String userAnswer, String question, String jobTitle) {
        StringBuilder prompt = new StringBuilder();
        
        prompt.append("任务：你是一名专业的面试官，请根据用户的回答和相关信息，对其面试表现进行全面分析。\n\n");
        
        prompt.append("用户简历摘要：").append(resumeText).append("\n\n");
        
        prompt.append("面试问题：").append(question).append("\n\n");
        
        prompt.append("用户回答：").append(userAnswer).append("\n\n");
        
        prompt.append("应聘岗位：").append(jobTitle).append("\n\n");
        
        prompt.append("分析维度：\n");
        prompt.append("1. 总体评分（1-100分）\n");
        prompt.append("2. 能力维度评分（包括：专业能力、沟通能力、解决问题能力、学习能力、团队合作能力，每项1-100分）\n");
        prompt.append("3. 回答的优势（至少2点）\n");
        prompt.append("4. 回答的改进建议（至少2点）\n");
        prompt.append("5. 总体评价（简要总结用户的表现）\n\n");
        
        prompt.append("请你按照严格的JSON格式输出分析结果，不要包含任何额外的解释性文字。JSON格式如下：\n");
        prompt.append("{\n");
        prompt.append("  \"overallScore\": 85,\n");
        prompt.append("  \"skillScores\": {\n");
        prompt.append("    \"专业能力\": 88,\n");
        prompt.append("    \"沟通能力\": 82,\n");
        prompt.append("    \"解决问题能力\": 86,\n");
        prompt.append("    \"学习能力\": 80,\n");
        prompt.append("    \"团队合作能力\": 83\n");
        prompt.append("  },\n");
        prompt.append("  \"advantages\": [\"优势1\", \"优势2\"],\n");
        prompt.append("  \"suggestions\": [\"建议1\", \"建议2\"],\n");
        prompt.append("  \"overallComment\": \"总体评价文字\"\n");
        prompt.append("}");
        
        return prompt.toString();
    }
    
    // 解析AI的分析响应
    private InterviewAnalysis parseAnalysisResponse(String response) {
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            return objectMapper.readValue(response, InterviewAnalysis.class);
        } catch (Exception e) {
            logger.error("解析AI分析响应失败: {}", e.getMessage(), e);
            // 如果解析失败，返回一个模拟的分析结果
            InterviewAnalysis fallbackAnalysis = new InterviewAnalysis();
            fallbackAnalysis.setScore(75.0);
            
            List<String> strengths = new ArrayList<>();
            strengths.add("回答基本切题");
            strengths.add("能够提供相关信息");
            fallbackAnalysis.setStrengths(strengths);
            
            List<String> areasForImprovement = new ArrayList<>();
            areasForImprovement.add("可以更详细地阐述观点");
            areasForImprovement.add("建议结合具体案例进行说明");
            fallbackAnalysis.setAreasForImprovement(areasForImprovement);
            
            fallbackAnalysis.setSuggestion("回答符合基本要求，但可以更加深入和具体。");
            
            return fallbackAnalysis;
        }
    }
    
    // 重复的buildSingleExampleAnswerPrompt方法已移除，保留了之前的实现
    
    // 生成模拟简历分析
    private String generateMockResumeAnalysis() {
        return "匹配度：78\n" +
               "优势：有相关工作经验，掌握必要的技术技能，教育背景符合要求。\n" +
               "不足：项目经验描述不够详细，缺乏量化成果，部分技能描述不够具体。\n" +
               "建议：突出项目中的具体贡献和成果，增加技术细节描述，补充团队协作经验。\n" +
               "格式优化建议：使用清晰的标题层级，突出重点内容，控制简历长度在一页内。";
    }

    // 调用DeepSeek API
    private String callDeepSeekApi(String prompt) throws Exception {
        try {
            // 创建请求头
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            headers.setBearerAuth(config.getApiKey());

            // 创建请求体
            Map<String, Object> requestBody = new HashMap<>();
            requestBody.put("model", config.getModel());
            // 使用Java 1.8兼容的方式创建Map
            Map<String, String> messageMap = new HashMap<>();
            messageMap.put("role", "user");
            messageMap.put("content", prompt);
            requestBody.put("messages", Collections.singletonList(messageMap));
            requestBody.put("temperature", config.getTemperature());
            requestBody.put("max_tokens", config.getMaxTokens());

            // 创建HTTP请求
            HttpEntity<Map<String, Object>> request = new HttpEntity<>(requestBody, headers);

            // 构建完整的API URL，添加chat/completions路径
            String apiUrl = config.getBaseUrl() +
                    (config.getBaseUrl().endsWith("/") ? "" : "/") +
                    "chat/completions";

            // 发送请求并获取响应
            ResponseEntity<DeepSeekResponse> responseEntity = restTemplate.postForEntity(
                    apiUrl, request, DeepSeekResponse.class);

            // 解析响应内容
            if (responseEntity != null && responseEntity.getStatusCode().is2xxSuccessful()) {
                DeepSeekResponse responseBody = responseEntity.getBody();
                if (responseBody != null && responseBody.getChoices() != null && !responseBody.getChoices().isEmpty()) {
                    DeepSeekResponse.Choice choice = responseBody.getChoices().get(0);
                    if (choice != null && choice.getMessage() != null) {
                        return choice.getMessage().getContent();
                    }
                }
            }

            throw new Exception("API响应为空或格式不正确");
        } catch (Exception e) {
            logger.error("调用DeepSeek API失败: {}", e.getMessage());
            throw e;
        }
    }

    // 解析生成的问题
    private List<String> parseGeneratedQuestions(String response) {
        List<String> questions = new ArrayList<>();

        if (response == null || response.isEmpty()) {
            return questions;
        }

        // 按行分割响应内容
        String[] lines = response.split("\\n");

        for (String line : lines) {
            line = line.trim();
            // 移除可能的序号和标记
            if (line.matches("^\\d+\\.\\s+.*")) {
                line = line.replaceFirst("^\\d+\\.\\s+", "");
            } else if (line.matches("^[•-]\\s+.*")) {
                line = line.replaceFirst("^[•-]\\s+", "");
            }

            // 只添加非空的问题
            if (!line.isEmpty() && line.endsWith("？")) {
                questions.add(line);
            }
        }

        return questions;
    }

    // 提取单个问题
    private String extractSingleQuestion(String response) {
        if (response == null || response.isEmpty()) {
            return "请分享一下您对这个领域的理解和经验。";
        }

        // 清理响应内容，移除可能的格式标记
        String question = response.trim();
        if (question.matches("^\\d+\\.\\s+.*")) {
            question = question.replaceFirst("^\\d+\\.\\s+", "");
        }

        // 确保问题以问号结尾
        if (!question.endsWith("？")) {
            question += "？";
        }

        return question;
    }

    // 解析面试分析结果
    private InterviewAnalysis parseInterviewAnalysis(String response) {
        InterviewAnalysis analysis = new InterviewAnalysis();
        try {
            Double score = extractValue(response, "面试得分：", Double.class);
            analysis.setScore(score != null ? score : 75.0);

            String suggestion = extractValue(response, "综合评价：", String.class);
            analysis.setSuggestion(suggestion != null ? suggestion : "您的面试表现基本符合要求，有一定的专业基础。");

            String strengthsStr = extractValue(response, "优势：", String.class);
            if (strengthsStr != null && !strengthsStr.isEmpty()) {
                List<String> strengths = Arrays.asList(strengthsStr.split("，"));
                analysis.setStrengths(new ArrayList<>(strengths));
            } else {
                analysis.setStrengths(Arrays.asList("沟通能力良好", "专业知识扎实", "态度积极"));
            }

            String improvementsStr = extractValue(response, "改进建议：", String.class);
            if (improvementsStr != null && !improvementsStr.isEmpty()) {
                List<String> improvements = Arrays.asList(improvementsStr.split("，"));
                analysis.setAreasForImprovement(new ArrayList<>(improvements));
            } else {
                analysis.setAreasForImprovement(Arrays.asList("可以更详细地描述项目经验", "加强技术深度", "提高问题分析能力"));
            }

        } catch (Exception e) {
            logger.error("解析面试分析结果失败: {}", e.getMessage());
            return getDefaultInterviewAnalysis();
        }

        return analysis;
    }

    // 解析简历分析结果
    private ResumeAnalysis parseResumeAnalysis(String response) {
        ResumeAnalysis analysis = new ResumeAnalysis();
        try {
            Double matchScore = extractValue(response, "匹配度：", Double.class);
            analysis.setScore(matchScore != null ? matchScore : 70.0);

            String strengthsStr = extractValue(response, "优势：", String.class);
            if (strengthsStr != null && !strengthsStr.isEmpty()) {
                analysis.setStrengths(strengthsStr);
            } else {
                analysis.setStrengths("experienced in software industry");
            }

            String weaknessesStr = extractValue(response, "不足：", String.class);
            if (weaknessesStr != null && !weaknessesStr.isEmpty()) {
                analysis.setAreasForImprovement(weaknessesStr);
            } else {
                analysis.setAreasForImprovement("项目细节描述不足，技能展示不充分，缺乏量化成果");
            }

            String suggestions = extractValue(response, "建议：", String.class);
            analysis.setSuggestions(suggestions != null ? suggestions : "建议突出项目成果，量化工作业绩，增加专业技能的详细描述。");

            String formattingTips = extractValue(response, "格式优化建议：", String.class);
            analysis.setFormattingTips(formattingTips != null ? formattingTips : "使用清晰的标题层级，保持一致的格式，控制简历长度在1-2页。");

        } catch (Exception e) {
            logger.error("解析简历分析结果失败: {}", e.getMessage());
            return getDefaultResumeAnalysis();
        }

        return analysis;
    }

    // 解析示例答案
    private List<InterviewQA> parseExampleAnswers(String response, List<InterviewQA> originalQaList) {
        List<InterviewQA> exampleAnswers = new ArrayList<>();

        if (response == null || response.isEmpty()) {
            return generateDefaultExampleAnswers(originalQaList.get(0).getQuestion());
        }

        // 按行分割响应内容
        String[] lines = response.split("\\n");

        Map<Integer, String> exampleMap = new HashMap<>();
        for (String line : lines) {
            line = line.trim();
            // 提取示例答案
            if (line.startsWith("示例答案")) {
                try {
                    int idx = line.indexOf(":");
                    if (idx > 0) {
                        String numStr = line.substring(4, idx).trim();
                        int questionNum = Integer.parseInt(numStr);
                        String exampleAnswer = line.substring(idx + 1).trim();
                        exampleMap.put(questionNum, exampleAnswer);
                    }
                } catch (Exception e) {
                    logger.warn("解析示例答案行失败: {}", line);
                }
            }
        }

        // 合并原始问题和示例答案
        for (int i = 0; i < originalQaList.size(); i++) {
            InterviewQA qa = new InterviewQA();
            qa.setQuestion(originalQaList.get(i).getQuestion());

            // 获取对应的示例答案，如果没有则生成默认答案
            String exampleAnswer = exampleMap.get(i + 1);
            if (exampleAnswer == null || exampleAnswer.isEmpty()) {
                exampleAnswer = generateDefaultExampleAnswer(originalQaList.get(i).getQuestion());
            }
            qa.setAnswer(exampleAnswer);

            exampleAnswers.add(qa);
        }

        return exampleAnswers;
    }

    // 通用值提取方法
    private <T> T extractValue(String response, String prefix, Class<T> valueType) {
        if (response == null || !response.contains(prefix)) {
            return null;
        }

        int startIndex = response.indexOf(prefix) + prefix.length();
        int endIndex;

        // 如果是最后一个字段，取到字符串末尾
        if (response.substring(startIndex).contains("\n")) {
            endIndex = response.indexOf("\n", startIndex);
        } else {
            endIndex = response.length();
        }

        String valueStr = response.substring(startIndex, endIndex).trim();

        if (valueType == Double.class) {
            try {
                return valueType.cast(Double.parseDouble(valueStr));
            } catch (NumberFormatException e) {
                logger.warn("解析数字失败: {}", valueStr);
                return null;
            }
        } else if (valueType == String.class) {
            return valueType.cast(valueStr);
        }

        return null;
    }

    // 获取难度描述
    private String getDifficultyDescription(Integer difficulty) {
        // 添加null值检查，防止空指针异常
        if (difficulty == null) {
            return "中级";
        }

        switch (difficulty) {
            case 1:
                return "初级";
            case 2:
                return "基础";
            case 3:
                return "中级";
            case 4:
                return "高级";
            case 5:
                return "专家级";
            default:
                return "中级";
        }
    }

    // 如果生成的问题不足，添加默认问题
    private List<String> addDefaultQuestionsIfNeeded(List<String> generatedQuestions, String jobTitle,
            Integer targetCount) {
        List<String> result = new ArrayList<>(generatedQuestions);
        int neededCount = targetCount - generatedQuestions.size();

        if (neededCount > 0) {
            logger.info("生成的问题不足，需要补充 {} 个默认问题", neededCount);
            List<String> defaultQuestions = generateDefaultQuestions(jobTitle, neededCount);

            // 确保问题不重复
            Set<String> questionSet = new HashSet<>(result);
            for (String question : defaultQuestions) {
                if (!questionSet.contains(question)) {
                    result.add(question);
                    questionSet.add(question);
                    if (result.size() >= targetCount) {
                        break;
                    }
                }
            }
        }

        return result;
    }

    // 生成默认问题列表
    private List<String> generateDefaultQuestions(String jobTitle, Integer count) {
        List<String> defaultQuestions = new ArrayList<>();
        defaultQuestions.add("请简单介绍一下你自己。");
        defaultQuestions.add("你为什么对这个职位感兴趣？");
        defaultQuestions.add("你最大的优势是什么？");
        defaultQuestions.add("你认为自己需要改进的地方是什么？");
        defaultQuestions.add("你对我们公司有什么了解？");
        defaultQuestions.add("请描述一次你解决复杂问题的经历。");
        defaultQuestions.add("你如何处理工作中的压力和挑战？");
        defaultQuestions.add("你有什么职业规划？");
        defaultQuestions.add("你如何与团队成员合作完成项目？");
        defaultQuestions.add("你为什么认为自己适合这个职位？");

        // 根据职位调整默认问题
        if (jobTitle != null && !jobTitle.isEmpty()) {
            if (jobTitle.contains("开发") || jobTitle.contains("程序员") || jobTitle.contains("工程师")) {
                defaultQuestions.add("请描述您最熟悉的编程语言及其应用场景。");
                defaultQuestions.add("您如何解决代码中的bug？能分享一个具体案例吗？");
                defaultQuestions.add("您对软件开发流程有什么了解？请简要描述。");
            } else if (jobTitle.contains("销售") || jobTitle.contains("营销")) {
                defaultQuestions.add("您如何理解销售的本质？能分享一次成功的销售经历吗？");
                defaultQuestions.add("您如何处理客户的拒绝？");
                defaultQuestions.add("您如何制定销售目标和计划？");
            } else if (jobTitle.contains("管理") || jobTitle.contains("主管")) {
                defaultQuestions.add("您的管理理念是什么？请分享一次您带领团队完成目标的经历。");
                defaultQuestions.add("您如何激励团队成员？");
                defaultQuestions.add("您如何处理团队中的冲突？");
            }
        }

        // 返回所需数量的问题
        List<String> result = new ArrayList<>();
        for (int i = 0; i < count && i < defaultQuestions.size(); i++) {
            result.add(defaultQuestions.get(i));
        }

        // 如果默认问题不够，复制现有问题
        while (result.size() < count) {
            result.add(defaultQuestions.get(new Random().nextInt(defaultQuestions.size())));
        }

        return result;
    }

    // 生成单个默认问题
    private String generateDefaultSingleQuestion(String jobTitle) {
        List<String> defaultQuestions = generateDefaultQuestions(jobTitle, 10);
        return defaultQuestions.get(new Random().nextInt(defaultQuestions.size()));
    }

    // 获取默认面试分析结果
    private InterviewAnalysis getDefaultInterviewAnalysis() {
        InterviewAnalysis analysis = new InterviewAnalysis();
        analysis.setScore(75.0);
        analysis.setSuggestion("您的面试表现基本符合要求，有一定的专业基础。建议加强对行业知识的了解和实践经验的积累。");
        analysis.setStrengths(Arrays.asList("沟通能力良好", "专业知识扎实", "态度积极"));
        analysis.setAreasForImprovement(Arrays.asList("可以更详细地描述项目经验", "加强技术深度", "提高问题分析能力"));
        return analysis;
    }

    // 获取默认简历分析结果
    private ResumeAnalysis getDefaultResumeAnalysis() {
        ResumeAnalysis analysis = new ResumeAnalysis();
        analysis.setScore(70.0);
        analysis.setStrengths("experienced in software industry");
        analysis.setAreasForImprovement("项目细节描述不足，技能展示不充分，缺乏量化成果");
        analysis.setSuggestions("建议突出项目成果，量化工作业绩，增加专业技能的详细描述。");
        analysis.setFormattingTips("使用清晰的标题层级，保持一致的格式，控制简历长度在1-2页。");
        return analysis;
    }

    // 生成默认示例答案
    private List<InterviewQA> generateDefaultExampleAnswers(String jobTitle) {
        List<InterviewQA> exampleQas = new ArrayList<>();

        InterviewQA qa1 = new InterviewQA();
        qa1.setQuestion("请介绍一下您和自己的工作经历。");
        qa1.setAnswer(
                "您好，我叫张明，拥有5年的软件行业工作经验。过去3年我一直在XX科技担任Java开发工程师，负责企业级应用的设计和开发。我熟悉Java、Spring框架、MySQL等技术，参与过多个大型项目的开发和维护。我喜欢解决复杂的技术问题，并且注重团队合作。");
        exampleQas.add(qa1);

        InterviewQA qa2 = new InterviewQA();
        qa2.setQuestion("您为什么对这个职位感兴趣？");
        qa2.setAnswer(
                "我对这个职位感兴趣主要有两个原因。首先，贵公司在行业内有很好的声誉，我非常希望能在这样的平台上发展。其次，这个职位的职责与我的专业背景和职业规划非常匹配，我相信我可以在这个岗位上发挥我的专业技能，同时也能学习到更多新的知识和技能。");
        exampleQas.add(qa2);

        return exampleQas;
    }

    // 生成单个问题的默认示例答案
    private String generateDefaultExampleAnswer(String question) {
        if (question.contains("介绍自己")) {
            return "您好，我叫张明，拥有5年的相关工作经验。我熟悉本岗位所需的各项技能，参与过多个相关项目的开发和实施。我注重团队合作，善于沟通，并且有良好的问题解决能力。我相信我可以在这个岗位上发挥我的专业技能，为公司创造价值。";
        } else if (question.contains("为什么对这个职位感兴趣")) {
            return "我对这个职位感兴趣主要是因为它与我的专业背景和职业规划非常匹配。我希望能在这个岗位上发挥我的专业技能，同时也能学习到更多新的知识和技能，不断提升自己。我相信我可以为公司的发展做出贡献。";
        } else if (question.contains("技能")) {
            return "我认为我最适合这个职位的技能包括：专业知识扎实、问题解决能力强、团队协作能力好、学习能力强等。在过去的工作中，我通过不断学习和实践，积累了丰富的经验，这些经验使我能够更好地胜任这个职位。";
        } else {
            return "在我之前的工作中，我曾遇到过一个重大挑战。当时我们的项目面临时间紧、任务重、技术复杂度高的问题。我通过制定详细的工作计划，分解任务，与团队成员密切合作，并积极寻求外部资源支持，最终成功完成了项目，并且得到了客户的高度评价。这次经历让我深刻认识到了团队合作和有效沟通的重要性，也提高了我的问题解决能力和项目管理能力。";
        }
    }
}